package parserjc;

import parserjc.jaccie.*;

/**
 * Automatisch generierte Klasse
 * @author Jaccie
 */

public class Parser extends SICParser {

     String[] rule1 = {"Programm","ImportBereich","HauptProzedur"};
     String[] rule2 = {"Programm","HauptProzedur"};
     String[] rule3 = {"Programm","PackageBody"};
     String[] rule4 = {"ImportBereich","Import","ImportBereich"};
     String[] rule5 = {"ImportBereich","Import"};
     String[] rule6 = {"HauptProzedur","Prozedur"};
     String[] rule7 = {"PackageBody","packageP","bodyP","Identifier","isP","ProzedurDeklarationen","endP","Identifier","semikolonP"};
     String[] rule8 = {"Import","withP","LinkedName","semikolonP"};
     String[] rule9 = {"Import","useP","LinkedName","semikolonP"};
     String[] rule10 = {"Prozedur","procedureP","Identifier","ProzedurOptionals","beginP","Anwfolge","endP","Identifier","semikolonP"};
     String[] rule11 = {"ProzedurDeklarationen","DeklarationsBereich"};
     String[] rule12 = {"LinkedName","Identifier","punktP","Identifier"};
     String[] rule13 = {"LinkedName","Identifier"};
     String[] rule14 = {"ProzedurOptionals","openP","Parameter","closeP","isP","DeklarationsBereich"};
     String[] rule15 = {"ProzedurOptionals","openP","Parameter","closeP","isP"};
     String[] rule16 = {"ProzedurOptionals","isP","DeklarationsBereich"};
     String[] rule17 = {"Anwfolge","Anw","Anwfolge"};
     String[] rule18 = {"Anwfolge","Anw"};
     String[] rule19 = {"Parameter","ParameterDef","semikolonP","Parameter"};
     String[] rule20 = {"Parameter","ParameterDef"};
     String[] rule21 = {"DeklarationsBereich","Deklaration","DeklarationsBereich"};
     String[] rule22 = {"DeklarationsBereich","Deklaration"};
     String[] rule23 = {"Anw","Zusicherung"};
     String[] rule24 = {"Anw","AZuweisung"};
     String[] rule25 = {"Anw","AArrayZuweisung"};
     String[] rule26 = {"Anw","AProzedurAufruf"};
     String[] rule27 = {"Anw","ASchleife"};
     String[] rule28 = {"Anw","AFall"};
     String[] rule29 = {"ParameterDef","IdentifierList","dpunktP","ParameterMode","TypeAngabe","TypeInitialisierung"};
     String[] rule30 = {"Deklaration","Prozedur"};
     String[] rule31 = {"Deklaration","IdentifierList","dpunktP","TypeAngabe","TypeInitialisierung","semikolonP"};
     String[] rule32 = {"Zusicherung","zusicherungP","Identifier","dpunktP","Bedingungen"};
     String[] rule33 = {"Zusicherung","zusicherungP","Identifier","dpunktP","Ausdruck"};
     String[] rule34 = {"AZuweisung","Identifier","zuweisungP","Ausdruck","semikolonP"};
     String[] rule35 = {"AArrayZuweisung","ProzedurAufruf","zuweisungP","Ausdruck","semikolonP"};
     String[] rule36 = {"AProzedurAufruf","ProzedurAufruf","semikolonP"};
     String[] rule37 = {"ASchleife","whileP","Bedingungen","loopP","Anwfolge","endP","loopP","semikolonP"};
     String[] rule38 = {"AFall","ifP","Bedingungen","thenP","Anwfolge","endP","ifP","semikolonP"};
     String[] rule39 = {"AFall","ifP","Bedingungen","thenP","Anwfolge","elseP","Anwfolge","endP","ifP","semikolonP"};
     String[] rule40 = {"IdentifierList","Identifier","kommaP","IdentifierList"};
     String[] rule41 = {"IdentifierList","Identifier"};
     String[] rule42 = {"Identifier","identP"};
     String[] rule43 = {"ParameterMode","inP","outP"};
     String[] rule44 = {"ParameterMode","outP"};
     String[] rule45 = {"ParameterMode","inP"};
     String[] rule46 = {"ParameterMode"};
     String[] rule47 = {"TypeAngabe","ArrayType"};
     String[] rule48 = {"TypeAngabe","IntegerType"};
     String[] rule49 = {"IntegerType","integerP"};
     String[] rule50 = {"ArrayType","Identifier","ArrayDefBereich"};
     String[] rule51 = {"ArrayType","Identifier"};
     String[] rule52 = {"TypeInitialisierung","zuweisungP","AllWert"};
     String[] rule53 = {"TypeInitialisierung"};
     String[] rule54 = {"Bedingungen","notP","openP","Bedingungen","closeP"};
     String[] rule55 = {"Bedingungen","notP","Bedingung"};
     String[] rule56 = {"Bedingungen","openP","Bedingungen","closeP","LogiOp","Bedingungen"};
     String[] rule57 = {"Bedingungen","openP","Bedingungen","closeP"};
     String[] rule58 = {"Bedingungen","Bedingung","LogiOp","Bedingungen"};
     String[] rule59 = {"Bedingungen","Bedingung"};
     String[] rule60 = {"Bedingungen","Quantor"};
     String[] rule61 = {"Bedingung","Ausdruck","VergleichOp","Ausdruck"};
     String[] rule62 = {"Quantor","AllQuantor"};
     String[] rule63 = {"Quantor","ExQuantor"};
     String[] rule64 = {"AllQuantor","forallP","QuantorBedingungen"};
     String[] rule65 = {"ExQuantor","existsP","QuantorBedingungen"};
     String[] rule66 = {"QuantorBedingungen","Identifier","inP","openeP","ArrayRange","closeeP","dpunktP","Bedingungen"};
     String[] rule67 = {"LogiOp","andP","thenP"};
     String[] rule68 = {"LogiOp","orP","elseP"};
     String[] rule69 = {"LogiOp","andP"};
     String[] rule70 = {"LogiOp","orP"};
     String[] rule71 = {"VergleichOp","geP"};
     String[] rule72 = {"VergleichOp","gtP"};
     String[] rule73 = {"VergleichOp","ltP"};
     String[] rule74 = {"VergleichOp","leP"};
     String[] rule75 = {"VergleichOp","neP"};
     String[] rule76 = {"VergleichOp","eqP"};
     String[] rule77 = {"Ausdruck","Summe"};
     String[] rule78 = {"Summe","Produkt","AddsOp","Summe"};
     String[] rule79 = {"Summe","Produkt"};
     String[] rule80 = {"Produkt","Faktor","MultsOp","Produkt"};
     String[] rule81 = {"Produkt","Faktor"};
     String[] rule82 = {"AddsOp","plusP"};
     String[] rule83 = {"AddsOp","minusP"};
     String[] rule84 = {"Faktor","Term","HighPrecOp","Faktor"};
     String[] rule85 = {"Faktor","Term"};
     String[] rule86 = {"MultsOp","multP"};
     String[] rule87 = {"MultsOp","divP"};
     String[] rule88 = {"MultsOp","modP"};
     String[] rule89 = {"Term","openP","Summe","closeP"};
     String[] rule90 = {"Term","ExpWert"};
     String[] rule91 = {"HighPrecOp","multmultP"};
     String[] rule92 = {"ProzedurAufruf","LinkedName","openP","WertListe","closeP"};
     String[] rule93 = {"ProzedurAufruf","LinkedName","openP","closeP"};
     String[] rule94 = {"AllWert","ArrayWerte"};
     String[] rule95 = {"AllWert","ExpWert"};
     String[] rule96 = {"ExpWert","ProzedurAufruf"};
     String[] rule97 = {"ExpWert","Identifier"};
     String[] rule98 = {"ExpWert","IntWert"};
     String[] rule99 = {"ExpWert","minusP","ExpWert"};
     String[] rule100 = {"IntWert","ArrayKeyZugriff"};
     String[] rule101 = {"IntWert","numberP"};
     String[] rule102 = {"ArrayWerte","openP","WertListe","closeP"};
     String[] rule103 = {"ArrayDefBereich","openP","ArrayRange","closeP"};
     String[] rule104 = {"ArrayRange","ExpWert","ppunktP","ExpWert"};
     String[] rule105 = {"ArrayKeyZugriff","Identifier","firstP"};
     String[] rule106 = {"ArrayKeyZugriff","Identifier","lastP"};
     String[] rule107 = {"WertListe","ExpWert","WerteListe"};
     String[] rule108 = {"WertListe","ExpWert"};
     String[] rule109 = {"WerteListe","kommaP","ExpWert","WerteListe"};
     String[] rule110 = {"WerteListe","kommaP","ExpWert"};

     public Parser() {

          rule(1,rule1);
          rule(2,rule2);
          rule(3,rule3);
          rule(4,rule4);
          rule(5,rule5);
          rule(6,rule6);
          rule(7,rule7);
          rule(8,rule8);
          rule(9,rule9);
          rule(10,rule10);
          rule(11,rule11);
          rule(12,rule12);
          rule(13,rule13);
          rule(14,rule14);
          rule(15,rule15);
          rule(16,rule16);
          rule(17,rule17);
          rule(18,rule18);
          rule(19,rule19);
          rule(20,rule20);
          rule(21,rule21);
          rule(22,rule22);
          rule(23,rule23);
          rule(24,rule24);
          rule(25,rule25);
          rule(26,rule26);
          rule(27,rule27);
          rule(28,rule28);
          rule(29,rule29);
          rule(30,rule30);
          rule(31,rule31);
          rule(32,rule32);
          rule(33,rule33);
          rule(34,rule34);
          rule(35,rule35);
          rule(36,rule36);
          rule(37,rule37);
          rule(38,rule38);
          rule(39,rule39);
          rule(40,rule40);
          rule(41,rule41);
          rule(42,rule42);
          rule(43,rule43);
          rule(44,rule44);
          rule(45,rule45);
          rule(46,rule46);
          rule(47,rule47);
          rule(48,rule48);
          rule(49,rule49);
          rule(50,rule50);
          rule(51,rule51);
          rule(52,rule52);
          rule(53,rule53);
          rule(54,rule54);
          rule(55,rule55);
          rule(56,rule56);
          rule(57,rule57);
          rule(58,rule58);
          rule(59,rule59);
          rule(60,rule60);
          rule(61,rule61);
          rule(62,rule62);
          rule(63,rule63);
          rule(64,rule64);
          rule(65,rule65);
          rule(66,rule66);
          rule(67,rule67);
          rule(68,rule68);
          rule(69,rule69);
          rule(70,rule70);
          rule(71,rule71);
          rule(72,rule72);
          rule(73,rule73);
          rule(74,rule74);
          rule(75,rule75);
          rule(76,rule76);
          rule(77,rule77);
          rule(78,rule78);
          rule(79,rule79);
          rule(80,rule80);
          rule(81,rule81);
          rule(82,rule82);
          rule(83,rule83);
          rule(84,rule84);
          rule(85,rule85);
          rule(86,rule86);
          rule(87,rule87);
          rule(88,rule88);
          rule(89,rule89);
          rule(90,rule90);
          rule(91,rule91);
          rule(92,rule92);
          rule(93,rule93);
          rule(94,rule94);
          rule(95,rule95);
          rule(96,rule96);
          rule(97,rule97);
          rule(98,rule98);
          rule(99,rule99);
          rule(100,rule100);
          rule(101,rule101);
          rule(102,rule102);
          rule(103,rule103);
          rule(104,rule104);
          rule(105,rule105);
          rule(106,rule106);
          rule(107,rule107);
          rule(108,rule108);
          rule(109,rule109);
          rule(110,rule110);

          actionTable(1,"packageP",SHIFT,181);
          actionTable(1,"Import",SHIFT,203);
          actionTable(1,"procedureP",SHIFT,2);
          actionTable(1,"withP",SHIFT,190);
          actionTable(1,"HauptProzedur",SHIFT,201);
          actionTable(1,"Programm",SHIFT,197);
          actionTable(1,"useP",SHIFT,194);
          actionTable(1,"Prozedur",SHIFT,200);
          actionTable(1,"ImportBereich",SHIFT,198);
          actionTable(1,"PackageBody",SHIFT,202);

          actionTable(2,"Identifier",SHIFT,4);
          actionTable(2,"identP",SHIFT,3);

          actionTable(3,"openP",REDUCE,42);
          actionTable(3,"isP",REDUCE,42);
          actionTable(3,"semikolonP",REDUCE,42);
          actionTable(3,"punktP",REDUCE,42);
          actionTable(3,"dpunktP",REDUCE,42);
          actionTable(3,"kommaP",REDUCE,42);
          actionTable(3,"zuweisungP",REDUCE,42);
          actionTable(3,"lastP",REDUCE,42);
          actionTable(3,"firstP",REDUCE,42);
          actionTable(3,"geP",REDUCE,42);
          actionTable(3,"gtP",REDUCE,42);
          actionTable(3,"ltP",REDUCE,42);
          actionTable(3,"leP",REDUCE,42);
          actionTable(3,"neP",REDUCE,42);
          actionTable(3,"eqP",REDUCE,42);
          actionTable(3,"plusP",REDUCE,42);
          actionTable(3,"minusP",REDUCE,42);
          actionTable(3,"multP",REDUCE,42);
          actionTable(3,"divP",REDUCE,42);
          actionTable(3,"modP",REDUCE,42);
          actionTable(3,"multmultP",REDUCE,42);
          actionTable(3,"closeP",REDUCE,42);
          actionTable(3,"inP",REDUCE,42);
          actionTable(3,"ppunktP",REDUCE,42);
          actionTable(3,"loopP",REDUCE,42);
          actionTable(3,"andP",REDUCE,42);
          actionTable(3,"orP",REDUCE,42);
          actionTable(3,"thenP",REDUCE,42);
          actionTable(3,"endP",REDUCE,42);
          actionTable(3,"zusicherungP",REDUCE,42);
          actionTable(3,"whileP",REDUCE,42);
          actionTable(3,"ifP",REDUCE,42);
          actionTable(3,"identP",REDUCE,42);
          actionTable(3,"elseP",REDUCE,42);
          actionTable(3,"closeeP",REDUCE,42);

          actionTable(4,"openP",SHIFT,57);
          actionTable(4,"isP",SHIFT,5);
          actionTable(4,"ProzedurOptionals",SHIFT,73);

          actionTable(5,"Deklaration",SHIFT,8);
          actionTable(5,"procedureP",SHIFT,2);
          actionTable(5,"Identifier",SHIFT,54);
          actionTable(5,"Prozedur",SHIFT,6);
          actionTable(5,"identP",SHIFT,3);
          actionTable(5,"IdentifierList",SHIFT,10);
          actionTable(5,"DeklarationsBereich",SHIFT,7);

          actionTable(6,"beginP",REDUCE,30);
          actionTable(6,"procedureP",REDUCE,30);
          actionTable(6,"identP",REDUCE,30);
          actionTable(6,"endP",REDUCE,30);

          actionTable(7,"beginP",REDUCE,16);

          actionTable(8,"Deklaration",SHIFT,8);
          actionTable(8,"procedureP",SHIFT,2);
          actionTable(8,"Identifier",SHIFT,54);
          actionTable(8,"Prozedur",SHIFT,6);
          actionTable(8,"identP",SHIFT,3);
          actionTable(8,"IdentifierList",SHIFT,10);
          actionTable(8,"DeklarationsBereich",SHIFT,9);
          actionTable(8,"beginP",REDUCE,22);
          actionTable(8,"endP",REDUCE,22);

          actionTable(9,"beginP",REDUCE,21);
          actionTable(9,"endP",REDUCE,21);

          actionTable(10,"dpunktP",SHIFT,11);

          actionTable(11,"integerP",SHIFT,12);
          actionTable(11,"Identifier",SHIFT,13);
          actionTable(11,"ArrayType",SHIFT,53);
          actionTable(11,"identP",SHIFT,3);
          actionTable(11,"IntegerType",SHIFT,52);
          actionTable(11,"TypeAngabe",SHIFT,42);

          actionTable(12,"zuweisungP",REDUCE,49);
          actionTable(12,"semikolonP",REDUCE,49);
          actionTable(12,"closeP",REDUCE,49);

          actionTable(13,"openP",SHIFT,14);
          actionTable(13,"ArrayDefBereich",SHIFT,41);
          actionTable(13,"zuweisungP",REDUCE,51);
          actionTable(13,"semikolonP",REDUCE,51);
          actionTable(13,"closeP",REDUCE,51);

          actionTable(14,"IntWert",SHIFT,30);
          actionTable(14,"LinkedName",SHIFT,17);
          actionTable(14,"ExpWert",SHIFT,36);
          actionTable(14,"Identifier",SHIFT,20);
          actionTable(14,"ArrayRange",SHIFT,39);
          actionTable(14,"minusP",SHIFT,16);
          actionTable(14,"ArrayKeyZugriff",SHIFT,31);
          actionTable(14,"identP",SHIFT,3);
          actionTable(14,"numberP",SHIFT,15);
          actionTable(14,"ProzedurAufruf",SHIFT,25);

          actionTable(15,"geP",REDUCE,101);
          actionTable(15,"gtP",REDUCE,101);
          actionTable(15,"ltP",REDUCE,101);
          actionTable(15,"leP",REDUCE,101);
          actionTable(15,"neP",REDUCE,101);
          actionTable(15,"eqP",REDUCE,101);
          actionTable(15,"plusP",REDUCE,101);
          actionTable(15,"minusP",REDUCE,101);
          actionTable(15,"multP",REDUCE,101);
          actionTable(15,"divP",REDUCE,101);
          actionTable(15,"modP",REDUCE,101);
          actionTable(15,"multmultP",REDUCE,101);
          actionTable(15,"closeP",REDUCE,101);
          actionTable(15,"kommaP",REDUCE,101);
          actionTable(15,"semikolonP",REDUCE,101);
          actionTable(15,"ppunktP",REDUCE,101);
          actionTable(15,"loopP",REDUCE,101);
          actionTable(15,"andP",REDUCE,101);
          actionTable(15,"orP",REDUCE,101);
          actionTable(15,"thenP",REDUCE,101);
          actionTable(15,"endP",REDUCE,101);
          actionTable(15,"zusicherungP",REDUCE,101);
          actionTable(15,"whileP",REDUCE,101);
          actionTable(15,"ifP",REDUCE,101);
          actionTable(15,"identP",REDUCE,101);
          actionTable(15,"elseP",REDUCE,101);
          actionTable(15,"closeeP",REDUCE,101);

          actionTable(16,"IntWert",SHIFT,30);
          actionTable(16,"LinkedName",SHIFT,17);
          actionTable(16,"ExpWert",SHIFT,35);
          actionTable(16,"Identifier",SHIFT,20);
          actionTable(16,"minusP",SHIFT,16);
          actionTable(16,"ArrayKeyZugriff",SHIFT,31);
          actionTable(16,"identP",SHIFT,3);
          actionTable(16,"numberP",SHIFT,15);
          actionTable(16,"ProzedurAufruf",SHIFT,25);

          actionTable(17,"openP",SHIFT,18);

          actionTable(18,"IntWert",SHIFT,30);
          actionTable(18,"LinkedName",SHIFT,17);
          actionTable(18,"closeP",SHIFT,19);
          actionTable(18,"WertListe",SHIFT,33);
          actionTable(18,"ExpWert",SHIFT,26);
          actionTable(18,"Identifier",SHIFT,20);
          actionTable(18,"minusP",SHIFT,16);
          actionTable(18,"ArrayKeyZugriff",SHIFT,31);
          actionTable(18,"identP",SHIFT,3);
          actionTable(18,"numberP",SHIFT,15);
          actionTable(18,"ProzedurAufruf",SHIFT,25);

          actionTable(19,"semikolonP",REDUCE,93);
          actionTable(19,"zuweisungP",REDUCE,93);
          actionTable(19,"geP",REDUCE,93);
          actionTable(19,"gtP",REDUCE,93);
          actionTable(19,"ltP",REDUCE,93);
          actionTable(19,"leP",REDUCE,93);
          actionTable(19,"neP",REDUCE,93);
          actionTable(19,"eqP",REDUCE,93);
          actionTable(19,"plusP",REDUCE,93);
          actionTable(19,"minusP",REDUCE,93);
          actionTable(19,"multP",REDUCE,93);
          actionTable(19,"divP",REDUCE,93);
          actionTable(19,"modP",REDUCE,93);
          actionTable(19,"multmultP",REDUCE,93);
          actionTable(19,"closeP",REDUCE,93);
          actionTable(19,"kommaP",REDUCE,93);
          actionTable(19,"ppunktP",REDUCE,93);
          actionTable(19,"loopP",REDUCE,93);
          actionTable(19,"andP",REDUCE,93);
          actionTable(19,"orP",REDUCE,93);
          actionTable(19,"thenP",REDUCE,93);
          actionTable(19,"endP",REDUCE,93);
          actionTable(19,"zusicherungP",REDUCE,93);
          actionTable(19,"whileP",REDUCE,93);
          actionTable(19,"ifP",REDUCE,93);
          actionTable(19,"identP",REDUCE,93);
          actionTable(19,"elseP",REDUCE,93);
          actionTable(19,"closeeP",REDUCE,93);

          actionTable(20,"punktP",SHIFT,23);
          actionTable(20,"lastP",SHIFT,22);
          actionTable(20,"firstP",SHIFT,21);
          actionTable(20,"geP",REDUCE,97);
          actionTable(20,"gtP",REDUCE,97);
          actionTable(20,"ltP",REDUCE,97);
          actionTable(20,"leP",REDUCE,97);
          actionTable(20,"neP",REDUCE,97);
          actionTable(20,"eqP",REDUCE,97);
          actionTable(20,"plusP",REDUCE,97);
          actionTable(20,"minusP",REDUCE,97);
          actionTable(20,"multP",REDUCE,97);
          actionTable(20,"divP",REDUCE,97);
          actionTable(20,"modP",REDUCE,97);
          actionTable(20,"multmultP",REDUCE,97);
          actionTable(20,"closeP",REDUCE,97);
          actionTable(20,"kommaP",REDUCE,97);
          actionTable(20,"semikolonP",REDUCE,97);
          actionTable(20,"ppunktP",REDUCE,97);
          actionTable(20,"loopP",REDUCE,97);
          actionTable(20,"andP",REDUCE,97);
          actionTable(20,"orP",REDUCE,97);
          actionTable(20,"thenP",REDUCE,97);
          actionTable(20,"endP",REDUCE,97);
          actionTable(20,"zusicherungP",REDUCE,97);
          actionTable(20,"whileP",REDUCE,97);
          actionTable(20,"ifP",REDUCE,97);
          actionTable(20,"identP",REDUCE,97);
          actionTable(20,"elseP",REDUCE,97);
          actionTable(20,"closeeP",REDUCE,97);
          actionTable(20,"openP",REDUCE,13);

          actionTable(21,"geP",REDUCE,105);
          actionTable(21,"gtP",REDUCE,105);
          actionTable(21,"ltP",REDUCE,105);
          actionTable(21,"leP",REDUCE,105);
          actionTable(21,"neP",REDUCE,105);
          actionTable(21,"eqP",REDUCE,105);
          actionTable(21,"plusP",REDUCE,105);
          actionTable(21,"minusP",REDUCE,105);
          actionTable(21,"multP",REDUCE,105);
          actionTable(21,"divP",REDUCE,105);
          actionTable(21,"modP",REDUCE,105);
          actionTable(21,"multmultP",REDUCE,105);
          actionTable(21,"closeP",REDUCE,105);
          actionTable(21,"kommaP",REDUCE,105);
          actionTable(21,"semikolonP",REDUCE,105);
          actionTable(21,"ppunktP",REDUCE,105);
          actionTable(21,"loopP",REDUCE,105);
          actionTable(21,"andP",REDUCE,105);
          actionTable(21,"orP",REDUCE,105);
          actionTable(21,"thenP",REDUCE,105);
          actionTable(21,"endP",REDUCE,105);
          actionTable(21,"zusicherungP",REDUCE,105);
          actionTable(21,"whileP",REDUCE,105);
          actionTable(21,"ifP",REDUCE,105);
          actionTable(21,"identP",REDUCE,105);
          actionTable(21,"elseP",REDUCE,105);
          actionTable(21,"closeeP",REDUCE,105);

          actionTable(22,"geP",REDUCE,106);
          actionTable(22,"gtP",REDUCE,106);
          actionTable(22,"ltP",REDUCE,106);
          actionTable(22,"leP",REDUCE,106);
          actionTable(22,"neP",REDUCE,106);
          actionTable(22,"eqP",REDUCE,106);
          actionTable(22,"plusP",REDUCE,106);
          actionTable(22,"minusP",REDUCE,106);
          actionTable(22,"multP",REDUCE,106);
          actionTable(22,"divP",REDUCE,106);
          actionTable(22,"modP",REDUCE,106);
          actionTable(22,"multmultP",REDUCE,106);
          actionTable(22,"closeP",REDUCE,106);
          actionTable(22,"kommaP",REDUCE,106);
          actionTable(22,"semikolonP",REDUCE,106);
          actionTable(22,"ppunktP",REDUCE,106);
          actionTable(22,"loopP",REDUCE,106);
          actionTable(22,"andP",REDUCE,106);
          actionTable(22,"orP",REDUCE,106);
          actionTable(22,"thenP",REDUCE,106);
          actionTable(22,"endP",REDUCE,106);
          actionTable(22,"zusicherungP",REDUCE,106);
          actionTable(22,"whileP",REDUCE,106);
          actionTable(22,"ifP",REDUCE,106);
          actionTable(22,"identP",REDUCE,106);
          actionTable(22,"elseP",REDUCE,106);
          actionTable(22,"closeeP",REDUCE,106);

          actionTable(23,"Identifier",SHIFT,24);
          actionTable(23,"identP",SHIFT,3);

          actionTable(24,"semikolonP",REDUCE,12);
          actionTable(24,"openP",REDUCE,12);

          actionTable(25,"geP",REDUCE,96);
          actionTable(25,"gtP",REDUCE,96);
          actionTable(25,"ltP",REDUCE,96);
          actionTable(25,"leP",REDUCE,96);
          actionTable(25,"neP",REDUCE,96);
          actionTable(25,"eqP",REDUCE,96);
          actionTable(25,"plusP",REDUCE,96);
          actionTable(25,"minusP",REDUCE,96);
          actionTable(25,"multP",REDUCE,96);
          actionTable(25,"divP",REDUCE,96);
          actionTable(25,"modP",REDUCE,96);
          actionTable(25,"multmultP",REDUCE,96);
          actionTable(25,"closeP",REDUCE,96);
          actionTable(25,"kommaP",REDUCE,96);
          actionTable(25,"semikolonP",REDUCE,96);
          actionTable(25,"ppunktP",REDUCE,96);
          actionTable(25,"loopP",REDUCE,96);
          actionTable(25,"andP",REDUCE,96);
          actionTable(25,"orP",REDUCE,96);
          actionTable(25,"thenP",REDUCE,96);
          actionTable(25,"endP",REDUCE,96);
          actionTable(25,"zusicherungP",REDUCE,96);
          actionTable(25,"whileP",REDUCE,96);
          actionTable(25,"ifP",REDUCE,96);
          actionTable(25,"identP",REDUCE,96);
          actionTable(25,"elseP",REDUCE,96);
          actionTable(25,"closeeP",REDUCE,96);

          actionTable(26,"WerteListe",SHIFT,32);
          actionTable(26,"kommaP",SHIFT,27);
          actionTable(26,"closeP",REDUCE,108);

          actionTable(27,"IntWert",SHIFT,30);
          actionTable(27,"LinkedName",SHIFT,17);
          actionTable(27,"ExpWert",SHIFT,28);
          actionTable(27,"Identifier",SHIFT,20);
          actionTable(27,"minusP",SHIFT,16);
          actionTable(27,"ArrayKeyZugriff",SHIFT,31);
          actionTable(27,"identP",SHIFT,3);
          actionTable(27,"numberP",SHIFT,15);
          actionTable(27,"ProzedurAufruf",SHIFT,25);

          actionTable(28,"WerteListe",SHIFT,29);
          actionTable(28,"kommaP",SHIFT,27);
          actionTable(28,"closeP",REDUCE,110);

          actionTable(29,"closeP",REDUCE,109);

          actionTable(30,"geP",REDUCE,98);
          actionTable(30,"gtP",REDUCE,98);
          actionTable(30,"ltP",REDUCE,98);
          actionTable(30,"leP",REDUCE,98);
          actionTable(30,"neP",REDUCE,98);
          actionTable(30,"eqP",REDUCE,98);
          actionTable(30,"plusP",REDUCE,98);
          actionTable(30,"minusP",REDUCE,98);
          actionTable(30,"multP",REDUCE,98);
          actionTable(30,"divP",REDUCE,98);
          actionTable(30,"modP",REDUCE,98);
          actionTable(30,"multmultP",REDUCE,98);
          actionTable(30,"closeP",REDUCE,98);
          actionTable(30,"kommaP",REDUCE,98);
          actionTable(30,"semikolonP",REDUCE,98);
          actionTable(30,"ppunktP",REDUCE,98);
          actionTable(30,"loopP",REDUCE,98);
          actionTable(30,"andP",REDUCE,98);
          actionTable(30,"orP",REDUCE,98);
          actionTable(30,"thenP",REDUCE,98);
          actionTable(30,"endP",REDUCE,98);
          actionTable(30,"zusicherungP",REDUCE,98);
          actionTable(30,"whileP",REDUCE,98);
          actionTable(30,"ifP",REDUCE,98);
          actionTable(30,"identP",REDUCE,98);
          actionTable(30,"elseP",REDUCE,98);
          actionTable(30,"closeeP",REDUCE,98);

          actionTable(31,"geP",REDUCE,100);
          actionTable(31,"gtP",REDUCE,100);
          actionTable(31,"ltP",REDUCE,100);
          actionTable(31,"leP",REDUCE,100);
          actionTable(31,"neP",REDUCE,100);
          actionTable(31,"eqP",REDUCE,100);
          actionTable(31,"plusP",REDUCE,100);
          actionTable(31,"minusP",REDUCE,100);
          actionTable(31,"multP",REDUCE,100);
          actionTable(31,"divP",REDUCE,100);
          actionTable(31,"modP",REDUCE,100);
          actionTable(31,"multmultP",REDUCE,100);
          actionTable(31,"closeP",REDUCE,100);
          actionTable(31,"kommaP",REDUCE,100);
          actionTable(31,"semikolonP",REDUCE,100);
          actionTable(31,"ppunktP",REDUCE,100);
          actionTable(31,"loopP",REDUCE,100);
          actionTable(31,"andP",REDUCE,100);
          actionTable(31,"orP",REDUCE,100);
          actionTable(31,"thenP",REDUCE,100);
          actionTable(31,"endP",REDUCE,100);
          actionTable(31,"zusicherungP",REDUCE,100);
          actionTable(31,"whileP",REDUCE,100);
          actionTable(31,"ifP",REDUCE,100);
          actionTable(31,"identP",REDUCE,100);
          actionTable(31,"elseP",REDUCE,100);
          actionTable(31,"closeeP",REDUCE,100);

          actionTable(32,"closeP",REDUCE,107);

          actionTable(33,"closeP",SHIFT,34);

          actionTable(34,"semikolonP",REDUCE,92);
          actionTable(34,"zuweisungP",REDUCE,92);
          actionTable(34,"geP",REDUCE,92);
          actionTable(34,"gtP",REDUCE,92);
          actionTable(34,"ltP",REDUCE,92);
          actionTable(34,"leP",REDUCE,92);
          actionTable(34,"neP",REDUCE,92);
          actionTable(34,"eqP",REDUCE,92);
          actionTable(34,"plusP",REDUCE,92);
          actionTable(34,"minusP",REDUCE,92);
          actionTable(34,"multP",REDUCE,92);
          actionTable(34,"divP",REDUCE,92);
          actionTable(34,"modP",REDUCE,92);
          actionTable(34,"multmultP",REDUCE,92);
          actionTable(34,"closeP",REDUCE,92);
          actionTable(34,"kommaP",REDUCE,92);
          actionTable(34,"ppunktP",REDUCE,92);
          actionTable(34,"loopP",REDUCE,92);
          actionTable(34,"andP",REDUCE,92);
          actionTable(34,"orP",REDUCE,92);
          actionTable(34,"thenP",REDUCE,92);
          actionTable(34,"endP",REDUCE,92);
          actionTable(34,"zusicherungP",REDUCE,92);
          actionTable(34,"whileP",REDUCE,92);
          actionTable(34,"ifP",REDUCE,92);
          actionTable(34,"identP",REDUCE,92);
          actionTable(34,"elseP",REDUCE,92);
          actionTable(34,"closeeP",REDUCE,92);

          actionTable(35,"geP",REDUCE,99);
          actionTable(35,"gtP",REDUCE,99);
          actionTable(35,"ltP",REDUCE,99);
          actionTable(35,"leP",REDUCE,99);
          actionTable(35,"neP",REDUCE,99);
          actionTable(35,"eqP",REDUCE,99);
          actionTable(35,"plusP",REDUCE,99);
          actionTable(35,"minusP",REDUCE,99);
          actionTable(35,"multP",REDUCE,99);
          actionTable(35,"divP",REDUCE,99);
          actionTable(35,"modP",REDUCE,99);
          actionTable(35,"multmultP",REDUCE,99);
          actionTable(35,"closeP",REDUCE,99);
          actionTable(35,"kommaP",REDUCE,99);
          actionTable(35,"semikolonP",REDUCE,99);
          actionTable(35,"ppunktP",REDUCE,99);
          actionTable(35,"loopP",REDUCE,99);
          actionTable(35,"andP",REDUCE,99);
          actionTable(35,"orP",REDUCE,99);
          actionTable(35,"thenP",REDUCE,99);
          actionTable(35,"endP",REDUCE,99);
          actionTable(35,"zusicherungP",REDUCE,99);
          actionTable(35,"whileP",REDUCE,99);
          actionTable(35,"ifP",REDUCE,99);
          actionTable(35,"identP",REDUCE,99);
          actionTable(35,"elseP",REDUCE,99);
          actionTable(35,"closeeP",REDUCE,99);

          actionTable(36,"ppunktP",SHIFT,37);

          actionTable(37,"IntWert",SHIFT,30);
          actionTable(37,"LinkedName",SHIFT,17);
          actionTable(37,"ExpWert",SHIFT,38);
          actionTable(37,"Identifier",SHIFT,20);
          actionTable(37,"minusP",SHIFT,16);
          actionTable(37,"ArrayKeyZugriff",SHIFT,31);
          actionTable(37,"identP",SHIFT,3);
          actionTable(37,"numberP",SHIFT,15);
          actionTable(37,"ProzedurAufruf",SHIFT,25);

          actionTable(38,"closeP",REDUCE,104);
          actionTable(38,"closeeP",REDUCE,104);

          actionTable(39,"closeP",SHIFT,40);

          actionTable(40,"zuweisungP",REDUCE,103);
          actionTable(40,"semikolonP",REDUCE,103);
          actionTable(40,"closeP",REDUCE,103);

          actionTable(41,"zuweisungP",REDUCE,50);
          actionTable(41,"semikolonP",REDUCE,50);
          actionTable(41,"closeP",REDUCE,50);

          actionTable(42,"zuweisungP",SHIFT,43);
          actionTable(42,"TypeInitialisierung",SHIFT,50);
          actionTable(42,"semikolonP",REDUCE,53);

          actionTable(43,"IntWert",SHIFT,30);
          actionTable(43,"LinkedName",SHIFT,17);
          actionTable(43,"openP",SHIFT,44);
          actionTable(43,"ExpWert",SHIFT,48);
          actionTable(43,"Identifier",SHIFT,20);
          actionTable(43,"minusP",SHIFT,16);
          actionTable(43,"ArrayKeyZugriff",SHIFT,31);
          actionTable(43,"AllWert",SHIFT,47);
          actionTable(43,"ArrayWerte",SHIFT,49);
          actionTable(43,"identP",SHIFT,3);
          actionTable(43,"numberP",SHIFT,15);
          actionTable(43,"ProzedurAufruf",SHIFT,25);

          actionTable(44,"IntWert",SHIFT,30);
          actionTable(44,"LinkedName",SHIFT,17);
          actionTable(44,"WertListe",SHIFT,45);
          actionTable(44,"ExpWert",SHIFT,26);
          actionTable(44,"Identifier",SHIFT,20);
          actionTable(44,"minusP",SHIFT,16);
          actionTable(44,"ArrayKeyZugriff",SHIFT,31);
          actionTable(44,"identP",SHIFT,3);
          actionTable(44,"numberP",SHIFT,15);
          actionTable(44,"ProzedurAufruf",SHIFT,25);

          actionTable(45,"closeP",SHIFT,46);

          actionTable(46,"semikolonP",REDUCE,102);
          actionTable(46,"closeP",REDUCE,102);

          actionTable(47,"semikolonP",REDUCE,52);
          actionTable(47,"closeP",REDUCE,52);

          actionTable(48,"semikolonP",REDUCE,95);
          actionTable(48,"closeP",REDUCE,95);

          actionTable(49,"semikolonP",REDUCE,94);
          actionTable(49,"closeP",REDUCE,94);

          actionTable(50,"semikolonP",SHIFT,51);

          actionTable(51,"beginP",REDUCE,31);
          actionTable(51,"procedureP",REDUCE,31);
          actionTable(51,"identP",REDUCE,31);
          actionTable(51,"endP",REDUCE,31);

          actionTable(52,"zuweisungP",REDUCE,48);
          actionTable(52,"semikolonP",REDUCE,48);
          actionTable(52,"closeP",REDUCE,48);

          actionTable(53,"zuweisungP",REDUCE,47);
          actionTable(53,"semikolonP",REDUCE,47);
          actionTable(53,"closeP",REDUCE,47);

          actionTable(54,"kommaP",SHIFT,55);
          actionTable(54,"dpunktP",REDUCE,41);

          actionTable(55,"Identifier",SHIFT,54);
          actionTable(55,"identP",SHIFT,3);
          actionTable(55,"IdentifierList",SHIFT,56);

          actionTable(56,"dpunktP",REDUCE,40);

          actionTable(57,"Identifier",SHIFT,54);
          actionTable(57,"Parameter",SHIFT,58);
          actionTable(57,"identP",SHIFT,3);
          actionTable(57,"IdentifierList",SHIFT,65);
          actionTable(57,"ParameterDef",SHIFT,62);

          actionTable(58,"closeP",SHIFT,59);

          actionTable(59,"isP",SHIFT,60);

          actionTable(60,"Deklaration",SHIFT,8);
          actionTable(60,"procedureP",SHIFT,2);
          actionTable(60,"Identifier",SHIFT,54);
          actionTable(60,"Prozedur",SHIFT,6);
          actionTable(60,"identP",SHIFT,3);
          actionTable(60,"IdentifierList",SHIFT,10);
          actionTable(60,"DeklarationsBereich",SHIFT,61);
          actionTable(60,"beginP",REDUCE,15);

          actionTable(61,"beginP",REDUCE,14);

          actionTable(62,"semikolonP",SHIFT,63);
          actionTable(62,"closeP",REDUCE,20);

          actionTable(63,"Identifier",SHIFT,54);
          actionTable(63,"Parameter",SHIFT,64);
          actionTable(63,"identP",SHIFT,3);
          actionTable(63,"IdentifierList",SHIFT,65);
          actionTable(63,"ParameterDef",SHIFT,62);

          actionTable(64,"closeP",REDUCE,19);

          actionTable(65,"dpunktP",SHIFT,66);

          actionTable(66,"inP",SHIFT,68);
          actionTable(66,"outP",SHIFT,67);
          actionTable(66,"ParameterMode",SHIFT,70);
          actionTable(66,"identP",REDUCE,46);
          actionTable(66,"integerP",REDUCE,46);

          actionTable(67,"identP",REDUCE,44);
          actionTable(67,"integerP",REDUCE,44);

          actionTable(68,"outP",SHIFT,69);
          actionTable(68,"identP",REDUCE,45);
          actionTable(68,"integerP",REDUCE,45);

          actionTable(69,"identP",REDUCE,43);
          actionTable(69,"integerP",REDUCE,43);

          actionTable(70,"integerP",SHIFT,12);
          actionTable(70,"Identifier",SHIFT,13);
          actionTable(70,"ArrayType",SHIFT,53);
          actionTable(70,"identP",SHIFT,3);
          actionTable(70,"IntegerType",SHIFT,52);
          actionTable(70,"TypeAngabe",SHIFT,71);

          actionTable(71,"zuweisungP",SHIFT,43);
          actionTable(71,"TypeInitialisierung",SHIFT,72);
          actionTable(71,"closeP",REDUCE,53);
          actionTable(71,"semikolonP",REDUCE,53);

          actionTable(72,"closeP",REDUCE,29);
          actionTable(72,"semikolonP",REDUCE,29);

          actionTable(73,"beginP",SHIFT,74);

          actionTable(74,"AProzedurAufruf",SHIFT,161);
          actionTable(74,"whileP",SHIFT,141);
          actionTable(74,"LinkedName",SHIFT,17);
          actionTable(74,"Anw",SHIFT,156);
          actionTable(74,"Zusicherung",SHIFT,158);
          actionTable(74,"Identifier",SHIFT,164);
          actionTable(74,"zusicherungP",SHIFT,75);
          actionTable(74,"AFall",SHIFT,163);
          actionTable(74,"Anwfolge",SHIFT,177);
          actionTable(74,"ifP",SHIFT,144);
          actionTable(74,"AZuweisung",SHIFT,159);
          actionTable(74,"identP",SHIFT,3);
          actionTable(74,"AArrayZuweisung",SHIFT,160);
          actionTable(74,"ProzedurAufruf",SHIFT,168);
          actionTable(74,"ASchleife",SHIFT,162);

          actionTable(75,"Identifier",SHIFT,76);
          actionTable(75,"identP",SHIFT,3);

          actionTable(76,"dpunktP",SHIFT,77);

          actionTable(77,"Summe",SHIFT,132);
          actionTable(77,"openP",SHIFT,89);
          actionTable(77,"numberP",SHIFT,15);
          actionTable(77,"ExpWert",SHIFT,130);
          actionTable(77,"Quantor",SHIFT,101);
          actionTable(77,"ExQuantor",SHIFT,103);
          actionTable(77,"Ausdruck",SHIFT,140);
          actionTable(77,"IntWert",SHIFT,30);
          actionTable(77,"Faktor",SHIFT,120);
          actionTable(77,"Produkt",SHIFT,115);
          actionTable(77,"existsP",SHIFT,78);
          actionTable(77,"minusP",SHIFT,16);
          actionTable(77,"AllQuantor",SHIFT,102);
          actionTable(77,"notP",SHIFT,87);
          actionTable(77,"Term",SHIFT,126);
          actionTable(77,"forallP",SHIFT,85);
          actionTable(77,"LinkedName",SHIFT,17);
          actionTable(77,"ArrayKeyZugriff",SHIFT,31);
          actionTable(77,"identP",SHIFT,3);
          actionTable(77,"Bedingung",SHIFT,98);
          actionTable(77,"Identifier",SHIFT,20);
          actionTable(77,"Bedingungen",SHIFT,139);
          actionTable(77,"ProzedurAufruf",SHIFT,25);

          actionTable(78,"QuantorBedingungen",SHIFT,138);
          actionTable(78,"Identifier",SHIFT,79);
          actionTable(78,"identP",SHIFT,3);

          actionTable(79,"inP",SHIFT,80);

          actionTable(80,"openeP",SHIFT,81);

          actionTable(81,"IntWert",SHIFT,30);
          actionTable(81,"LinkedName",SHIFT,17);
          actionTable(81,"ExpWert",SHIFT,36);
          actionTable(81,"Identifier",SHIFT,20);
          actionTable(81,"ArrayRange",SHIFT,82);
          actionTable(81,"minusP",SHIFT,16);
          actionTable(81,"ArrayKeyZugriff",SHIFT,31);
          actionTable(81,"identP",SHIFT,3);
          actionTable(81,"numberP",SHIFT,15);
          actionTable(81,"ProzedurAufruf",SHIFT,25);

          actionTable(82,"closeeP",SHIFT,83);

          actionTable(83,"dpunktP",SHIFT,84);

          actionTable(84,"Summe",SHIFT,132);
          actionTable(84,"openP",SHIFT,89);
          actionTable(84,"numberP",SHIFT,15);
          actionTable(84,"ExpWert",SHIFT,130);
          actionTable(84,"Quantor",SHIFT,101);
          actionTable(84,"ExQuantor",SHIFT,103);
          actionTable(84,"Ausdruck",SHIFT,104);
          actionTable(84,"IntWert",SHIFT,30);
          actionTable(84,"Faktor",SHIFT,120);
          actionTable(84,"Produkt",SHIFT,115);
          actionTable(84,"existsP",SHIFT,78);
          actionTable(84,"minusP",SHIFT,16);
          actionTable(84,"AllQuantor",SHIFT,102);
          actionTable(84,"notP",SHIFT,87);
          actionTable(84,"Term",SHIFT,126);
          actionTable(84,"forallP",SHIFT,85);
          actionTable(84,"LinkedName",SHIFT,17);
          actionTable(84,"ArrayKeyZugriff",SHIFT,31);
          actionTable(84,"identP",SHIFT,3);
          actionTable(84,"Bedingung",SHIFT,98);
          actionTable(84,"Identifier",SHIFT,20);
          actionTable(84,"Bedingungen",SHIFT,137);
          actionTable(84,"ProzedurAufruf",SHIFT,25);

          actionTable(85,"QuantorBedingungen",SHIFT,86);
          actionTable(85,"Identifier",SHIFT,79);
          actionTable(85,"identP",SHIFT,3);

          actionTable(86,"loopP",REDUCE,64);
          actionTable(86,"thenP",REDUCE,64);
          actionTable(86,"closeP",REDUCE,64);
          actionTable(86,"endP",REDUCE,64);
          actionTable(86,"zusicherungP",REDUCE,64);
          actionTable(86,"whileP",REDUCE,64);
          actionTable(86,"ifP",REDUCE,64);
          actionTable(86,"identP",REDUCE,64);
          actionTable(86,"elseP",REDUCE,64);

          actionTable(87,"Summe",SHIFT,132);
          actionTable(87,"openP",SHIFT,88);
          actionTable(87,"numberP",SHIFT,15);
          actionTable(87,"ExpWert",SHIFT,130);
          actionTable(87,"Ausdruck",SHIFT,104);
          actionTable(87,"IntWert",SHIFT,30);
          actionTable(87,"Faktor",SHIFT,120);
          actionTable(87,"Produkt",SHIFT,115);
          actionTable(87,"minusP",SHIFT,16);
          actionTable(87,"Term",SHIFT,126);
          actionTable(87,"LinkedName",SHIFT,17);
          actionTable(87,"ArrayKeyZugriff",SHIFT,31);
          actionTable(87,"identP",SHIFT,3);
          actionTable(87,"Bedingung",SHIFT,136);
          actionTable(87,"Identifier",SHIFT,20);
          actionTable(87,"ProzedurAufruf",SHIFT,25);

          actionTable(88,"Summe",SHIFT,133);
          actionTable(88,"openP",SHIFT,89);
          actionTable(88,"numberP",SHIFT,15);
          actionTable(88,"ExpWert",SHIFT,130);
          actionTable(88,"Quantor",SHIFT,101);
          actionTable(88,"ExQuantor",SHIFT,103);
          actionTable(88,"Ausdruck",SHIFT,104);
          actionTable(88,"IntWert",SHIFT,30);
          actionTable(88,"Faktor",SHIFT,120);
          actionTable(88,"Produkt",SHIFT,115);
          actionTable(88,"existsP",SHIFT,78);
          actionTable(88,"minusP",SHIFT,16);
          actionTable(88,"AllQuantor",SHIFT,102);
          actionTable(88,"notP",SHIFT,87);
          actionTable(88,"Term",SHIFT,126);
          actionTable(88,"forallP",SHIFT,85);
          actionTable(88,"LinkedName",SHIFT,17);
          actionTable(88,"ArrayKeyZugriff",SHIFT,31);
          actionTable(88,"identP",SHIFT,3);
          actionTable(88,"Bedingung",SHIFT,98);
          actionTable(88,"Identifier",SHIFT,20);
          actionTable(88,"Bedingungen",SHIFT,134);
          actionTable(88,"ProzedurAufruf",SHIFT,25);

          actionTable(89,"Summe",SHIFT,133);
          actionTable(89,"openP",SHIFT,89);
          actionTable(89,"numberP",SHIFT,15);
          actionTable(89,"ExpWert",SHIFT,130);
          actionTable(89,"Quantor",SHIFT,101);
          actionTable(89,"ExQuantor",SHIFT,103);
          actionTable(89,"Ausdruck",SHIFT,104);
          actionTable(89,"IntWert",SHIFT,30);
          actionTable(89,"Faktor",SHIFT,120);
          actionTable(89,"Produkt",SHIFT,115);
          actionTable(89,"existsP",SHIFT,78);
          actionTable(89,"minusP",SHIFT,16);
          actionTable(89,"AllQuantor",SHIFT,102);
          actionTable(89,"notP",SHIFT,87);
          actionTable(89,"Term",SHIFT,126);
          actionTable(89,"forallP",SHIFT,85);
          actionTable(89,"LinkedName",SHIFT,17);
          actionTable(89,"ArrayKeyZugriff",SHIFT,31);
          actionTable(89,"identP",SHIFT,3);
          actionTable(89,"Bedingung",SHIFT,98);
          actionTable(89,"Identifier",SHIFT,20);
          actionTable(89,"Bedingungen",SHIFT,90);
          actionTable(89,"ProzedurAufruf",SHIFT,25);

          actionTable(90,"closeP",SHIFT,91);

          actionTable(91,"LogiOp",SHIFT,96);
          actionTable(91,"andP",SHIFT,94);
          actionTable(91,"orP",SHIFT,92);
          actionTable(91,"loopP",REDUCE,57);
          actionTable(91,"thenP",REDUCE,57);
          actionTable(91,"closeP",REDUCE,57);
          actionTable(91,"endP",REDUCE,57);
          actionTable(91,"zusicherungP",REDUCE,57);
          actionTable(91,"whileP",REDUCE,57);
          actionTable(91,"ifP",REDUCE,57);
          actionTable(91,"identP",REDUCE,57);
          actionTable(91,"elseP",REDUCE,57);

          actionTable(92,"elseP",SHIFT,93);
          actionTable(92,"notP",REDUCE,70);
          actionTable(92,"openP",REDUCE,70);
          actionTable(92,"identP",REDUCE,70);
          actionTable(92,"minusP",REDUCE,70);
          actionTable(92,"numberP",REDUCE,70);
          actionTable(92,"forallP",REDUCE,70);
          actionTable(92,"existsP",REDUCE,70);

          actionTable(93,"notP",REDUCE,68);
          actionTable(93,"openP",REDUCE,68);
          actionTable(93,"identP",REDUCE,68);
          actionTable(93,"minusP",REDUCE,68);
          actionTable(93,"numberP",REDUCE,68);
          actionTable(93,"forallP",REDUCE,68);
          actionTable(93,"existsP",REDUCE,68);

          actionTable(94,"thenP",SHIFT,95);
          actionTable(94,"notP",REDUCE,69);
          actionTable(94,"openP",REDUCE,69);
          actionTable(94,"identP",REDUCE,69);
          actionTable(94,"minusP",REDUCE,69);
          actionTable(94,"numberP",REDUCE,69);
          actionTable(94,"forallP",REDUCE,69);
          actionTable(94,"existsP",REDUCE,69);

          actionTable(95,"notP",REDUCE,67);
          actionTable(95,"openP",REDUCE,67);
          actionTable(95,"identP",REDUCE,67);
          actionTable(95,"minusP",REDUCE,67);
          actionTable(95,"numberP",REDUCE,67);
          actionTable(95,"forallP",REDUCE,67);
          actionTable(95,"existsP",REDUCE,67);

          actionTable(96,"Summe",SHIFT,132);
          actionTable(96,"openP",SHIFT,89);
          actionTable(96,"numberP",SHIFT,15);
          actionTable(96,"ExpWert",SHIFT,130);
          actionTable(96,"Quantor",SHIFT,101);
          actionTable(96,"ExQuantor",SHIFT,103);
          actionTable(96,"Ausdruck",SHIFT,104);
          actionTable(96,"IntWert",SHIFT,30);
          actionTable(96,"Faktor",SHIFT,120);
          actionTable(96,"Produkt",SHIFT,115);
          actionTable(96,"existsP",SHIFT,78);
          actionTable(96,"minusP",SHIFT,16);
          actionTable(96,"AllQuantor",SHIFT,102);
          actionTable(96,"notP",SHIFT,87);
          actionTable(96,"Term",SHIFT,126);
          actionTable(96,"forallP",SHIFT,85);
          actionTable(96,"LinkedName",SHIFT,17);
          actionTable(96,"ArrayKeyZugriff",SHIFT,31);
          actionTable(96,"identP",SHIFT,3);
          actionTable(96,"Bedingung",SHIFT,98);
          actionTable(96,"Identifier",SHIFT,20);
          actionTable(96,"Bedingungen",SHIFT,97);
          actionTable(96,"ProzedurAufruf",SHIFT,25);

          actionTable(97,"loopP",REDUCE,56);
          actionTable(97,"thenP",REDUCE,56);
          actionTable(97,"closeP",REDUCE,56);
          actionTable(97,"endP",REDUCE,56);
          actionTable(97,"zusicherungP",REDUCE,56);
          actionTable(97,"whileP",REDUCE,56);
          actionTable(97,"ifP",REDUCE,56);
          actionTable(97,"identP",REDUCE,56);
          actionTable(97,"elseP",REDUCE,56);

          actionTable(98,"LogiOp",SHIFT,99);
          actionTable(98,"andP",SHIFT,94);
          actionTable(98,"orP",SHIFT,92);
          actionTable(98,"loopP",REDUCE,59);
          actionTable(98,"thenP",REDUCE,59);
          actionTable(98,"closeP",REDUCE,59);
          actionTable(98,"endP",REDUCE,59);
          actionTable(98,"zusicherungP",REDUCE,59);
          actionTable(98,"whileP",REDUCE,59);
          actionTable(98,"ifP",REDUCE,59);
          actionTable(98,"identP",REDUCE,59);
          actionTable(98,"elseP",REDUCE,59);

          actionTable(99,"Summe",SHIFT,132);
          actionTable(99,"openP",SHIFT,89);
          actionTable(99,"numberP",SHIFT,15);
          actionTable(99,"ExpWert",SHIFT,130);
          actionTable(99,"Quantor",SHIFT,101);
          actionTable(99,"ExQuantor",SHIFT,103);
          actionTable(99,"Ausdruck",SHIFT,104);
          actionTable(99,"IntWert",SHIFT,30);
          actionTable(99,"Faktor",SHIFT,120);
          actionTable(99,"Produkt",SHIFT,115);
          actionTable(99,"existsP",SHIFT,78);
          actionTable(99,"minusP",SHIFT,16);
          actionTable(99,"AllQuantor",SHIFT,102);
          actionTable(99,"notP",SHIFT,87);
          actionTable(99,"Term",SHIFT,126);
          actionTable(99,"forallP",SHIFT,85);
          actionTable(99,"LinkedName",SHIFT,17);
          actionTable(99,"ArrayKeyZugriff",SHIFT,31);
          actionTable(99,"identP",SHIFT,3);
          actionTable(99,"Bedingung",SHIFT,98);
          actionTable(99,"Identifier",SHIFT,20);
          actionTable(99,"Bedingungen",SHIFT,100);
          actionTable(99,"ProzedurAufruf",SHIFT,25);

          actionTable(100,"loopP",REDUCE,58);
          actionTable(100,"thenP",REDUCE,58);
          actionTable(100,"closeP",REDUCE,58);
          actionTable(100,"endP",REDUCE,58);
          actionTable(100,"zusicherungP",REDUCE,58);
          actionTable(100,"whileP",REDUCE,58);
          actionTable(100,"ifP",REDUCE,58);
          actionTable(100,"identP",REDUCE,58);
          actionTable(100,"elseP",REDUCE,58);

          actionTable(101,"loopP",REDUCE,60);
          actionTable(101,"thenP",REDUCE,60);
          actionTable(101,"closeP",REDUCE,60);
          actionTable(101,"endP",REDUCE,60);
          actionTable(101,"zusicherungP",REDUCE,60);
          actionTable(101,"whileP",REDUCE,60);
          actionTable(101,"ifP",REDUCE,60);
          actionTable(101,"identP",REDUCE,60);
          actionTable(101,"elseP",REDUCE,60);

          actionTable(102,"loopP",REDUCE,62);
          actionTable(102,"thenP",REDUCE,62);
          actionTable(102,"closeP",REDUCE,62);
          actionTable(102,"endP",REDUCE,62);
          actionTable(102,"zusicherungP",REDUCE,62);
          actionTable(102,"whileP",REDUCE,62);
          actionTable(102,"ifP",REDUCE,62);
          actionTable(102,"identP",REDUCE,62);
          actionTable(102,"elseP",REDUCE,62);

          actionTable(103,"loopP",REDUCE,63);
          actionTable(103,"thenP",REDUCE,63);
          actionTable(103,"closeP",REDUCE,63);
          actionTable(103,"endP",REDUCE,63);
          actionTable(103,"zusicherungP",REDUCE,63);
          actionTable(103,"whileP",REDUCE,63);
          actionTable(103,"ifP",REDUCE,63);
          actionTable(103,"identP",REDUCE,63);
          actionTable(103,"elseP",REDUCE,63);

          actionTable(104,"leP",SHIFT,108);
          actionTable(104,"gtP",SHIFT,106);
          actionTable(104,"geP",SHIFT,105);
          actionTable(104,"VergleichOp",SHIFT,111);
          actionTable(104,"eqP",SHIFT,110);
          actionTable(104,"ltP",SHIFT,107);
          actionTable(104,"neP",SHIFT,109);

          actionTable(105,"openP",REDUCE,71);
          actionTable(105,"identP",REDUCE,71);
          actionTable(105,"minusP",REDUCE,71);
          actionTable(105,"numberP",REDUCE,71);

          actionTable(106,"openP",REDUCE,72);
          actionTable(106,"identP",REDUCE,72);
          actionTable(106,"minusP",REDUCE,72);
          actionTable(106,"numberP",REDUCE,72);

          actionTable(107,"openP",REDUCE,73);
          actionTable(107,"identP",REDUCE,73);
          actionTable(107,"minusP",REDUCE,73);
          actionTable(107,"numberP",REDUCE,73);

          actionTable(108,"openP",REDUCE,74);
          actionTable(108,"identP",REDUCE,74);
          actionTable(108,"minusP",REDUCE,74);
          actionTable(108,"numberP",REDUCE,74);

          actionTable(109,"openP",REDUCE,75);
          actionTable(109,"identP",REDUCE,75);
          actionTable(109,"minusP",REDUCE,75);
          actionTable(109,"numberP",REDUCE,75);

          actionTable(110,"openP",REDUCE,76);
          actionTable(110,"identP",REDUCE,76);
          actionTable(110,"minusP",REDUCE,76);
          actionTable(110,"numberP",REDUCE,76);

          actionTable(111,"IntWert",SHIFT,30);
          actionTable(111,"Summe",SHIFT,132);
          actionTable(111,"LinkedName",SHIFT,17);
          actionTable(111,"Faktor",SHIFT,120);
          actionTable(111,"openP",SHIFT,112);
          actionTable(111,"ExpWert",SHIFT,130);
          actionTable(111,"Identifier",SHIFT,20);
          actionTable(111,"Term",SHIFT,126);
          actionTable(111,"Ausdruck",SHIFT,131);
          actionTable(111,"minusP",SHIFT,16);
          actionTable(111,"ArrayKeyZugriff",SHIFT,31);
          actionTable(111,"identP",SHIFT,3);
          actionTable(111,"Produkt",SHIFT,115);
          actionTable(111,"numberP",SHIFT,15);
          actionTable(111,"ProzedurAufruf",SHIFT,25);

          actionTable(112,"IntWert",SHIFT,30);
          actionTable(112,"Summe",SHIFT,113);
          actionTable(112,"LinkedName",SHIFT,17);
          actionTable(112,"Faktor",SHIFT,120);
          actionTable(112,"openP",SHIFT,112);
          actionTable(112,"ExpWert",SHIFT,130);
          actionTable(112,"Identifier",SHIFT,20);
          actionTable(112,"Term",SHIFT,126);
          actionTable(112,"minusP",SHIFT,16);
          actionTable(112,"ArrayKeyZugriff",SHIFT,31);
          actionTable(112,"identP",SHIFT,3);
          actionTable(112,"Produkt",SHIFT,115);
          actionTable(112,"numberP",SHIFT,15);
          actionTable(112,"ProzedurAufruf",SHIFT,25);

          actionTable(113,"closeP",SHIFT,114);

          actionTable(114,"geP",REDUCE,89);
          actionTable(114,"gtP",REDUCE,89);
          actionTable(114,"ltP",REDUCE,89);
          actionTable(114,"leP",REDUCE,89);
          actionTable(114,"neP",REDUCE,89);
          actionTable(114,"eqP",REDUCE,89);
          actionTable(114,"plusP",REDUCE,89);
          actionTable(114,"minusP",REDUCE,89);
          actionTable(114,"multP",REDUCE,89);
          actionTable(114,"divP",REDUCE,89);
          actionTable(114,"modP",REDUCE,89);
          actionTable(114,"multmultP",REDUCE,89);
          actionTable(114,"closeP",REDUCE,89);
          actionTable(114,"semikolonP",REDUCE,89);
          actionTable(114,"loopP",REDUCE,89);
          actionTable(114,"andP",REDUCE,89);
          actionTable(114,"orP",REDUCE,89);
          actionTable(114,"thenP",REDUCE,89);
          actionTable(114,"endP",REDUCE,89);
          actionTable(114,"zusicherungP",REDUCE,89);
          actionTable(114,"whileP",REDUCE,89);
          actionTable(114,"ifP",REDUCE,89);
          actionTable(114,"identP",REDUCE,89);
          actionTable(114,"elseP",REDUCE,89);

          actionTable(115,"AddsOp",SHIFT,118);
          actionTable(115,"minusP",SHIFT,116);
          actionTable(115,"plusP",SHIFT,117);
          actionTable(115,"geP",REDUCE,79);
          actionTable(115,"gtP",REDUCE,79);
          actionTable(115,"ltP",REDUCE,79);
          actionTable(115,"leP",REDUCE,79);
          actionTable(115,"neP",REDUCE,79);
          actionTable(115,"eqP",REDUCE,79);
          actionTable(115,"closeP",REDUCE,79);
          actionTable(115,"semikolonP",REDUCE,79);
          actionTable(115,"loopP",REDUCE,79);
          actionTable(115,"andP",REDUCE,79);
          actionTable(115,"orP",REDUCE,79);
          actionTable(115,"thenP",REDUCE,79);
          actionTable(115,"endP",REDUCE,79);
          actionTable(115,"zusicherungP",REDUCE,79);
          actionTable(115,"whileP",REDUCE,79);
          actionTable(115,"ifP",REDUCE,79);
          actionTable(115,"identP",REDUCE,79);
          actionTable(115,"elseP",REDUCE,79);

          actionTable(116,"openP",REDUCE,83);
          actionTable(116,"identP",REDUCE,83);
          actionTable(116,"minusP",REDUCE,83);
          actionTable(116,"numberP",REDUCE,83);

          actionTable(117,"openP",REDUCE,82);
          actionTable(117,"identP",REDUCE,82);
          actionTable(117,"minusP",REDUCE,82);
          actionTable(117,"numberP",REDUCE,82);

          actionTable(118,"IntWert",SHIFT,30);
          actionTable(118,"Summe",SHIFT,119);
          actionTable(118,"LinkedName",SHIFT,17);
          actionTable(118,"Faktor",SHIFT,120);
          actionTable(118,"openP",SHIFT,112);
          actionTable(118,"ExpWert",SHIFT,130);
          actionTable(118,"Identifier",SHIFT,20);
          actionTable(118,"Term",SHIFT,126);
          actionTable(118,"minusP",SHIFT,16);
          actionTable(118,"ArrayKeyZugriff",SHIFT,31);
          actionTable(118,"identP",SHIFT,3);
          actionTable(118,"Produkt",SHIFT,115);
          actionTable(118,"numberP",SHIFT,15);
          actionTable(118,"ProzedurAufruf",SHIFT,25);

          actionTable(119,"geP",REDUCE,78);
          actionTable(119,"gtP",REDUCE,78);
          actionTable(119,"ltP",REDUCE,78);
          actionTable(119,"leP",REDUCE,78);
          actionTable(119,"neP",REDUCE,78);
          actionTable(119,"eqP",REDUCE,78);
          actionTable(119,"closeP",REDUCE,78);
          actionTable(119,"semikolonP",REDUCE,78);
          actionTable(119,"loopP",REDUCE,78);
          actionTable(119,"andP",REDUCE,78);
          actionTable(119,"orP",REDUCE,78);
          actionTable(119,"thenP",REDUCE,78);
          actionTable(119,"endP",REDUCE,78);
          actionTable(119,"zusicherungP",REDUCE,78);
          actionTable(119,"whileP",REDUCE,78);
          actionTable(119,"ifP",REDUCE,78);
          actionTable(119,"identP",REDUCE,78);
          actionTable(119,"elseP",REDUCE,78);

          actionTable(120,"modP",SHIFT,121);
          actionTable(120,"divP",SHIFT,122);
          actionTable(120,"MultsOp",SHIFT,124);
          actionTable(120,"multP",SHIFT,123);
          actionTable(120,"geP",REDUCE,81);
          actionTable(120,"gtP",REDUCE,81);
          actionTable(120,"ltP",REDUCE,81);
          actionTable(120,"leP",REDUCE,81);
          actionTable(120,"neP",REDUCE,81);
          actionTable(120,"eqP",REDUCE,81);
          actionTable(120,"plusP",REDUCE,81);
          actionTable(120,"minusP",REDUCE,81);
          actionTable(120,"closeP",REDUCE,81);
          actionTable(120,"semikolonP",REDUCE,81);
          actionTable(120,"loopP",REDUCE,81);
          actionTable(120,"andP",REDUCE,81);
          actionTable(120,"orP",REDUCE,81);
          actionTable(120,"thenP",REDUCE,81);
          actionTable(120,"endP",REDUCE,81);
          actionTable(120,"zusicherungP",REDUCE,81);
          actionTable(120,"whileP",REDUCE,81);
          actionTable(120,"ifP",REDUCE,81);
          actionTable(120,"identP",REDUCE,81);
          actionTable(120,"elseP",REDUCE,81);

          actionTable(121,"openP",REDUCE,88);
          actionTable(121,"identP",REDUCE,88);
          actionTable(121,"minusP",REDUCE,88);
          actionTable(121,"numberP",REDUCE,88);

          actionTable(122,"openP",REDUCE,87);
          actionTable(122,"identP",REDUCE,87);
          actionTable(122,"minusP",REDUCE,87);
          actionTable(122,"numberP",REDUCE,87);

          actionTable(123,"openP",REDUCE,86);
          actionTable(123,"identP",REDUCE,86);
          actionTable(123,"minusP",REDUCE,86);
          actionTable(123,"numberP",REDUCE,86);

          actionTable(124,"IntWert",SHIFT,30);
          actionTable(124,"LinkedName",SHIFT,17);
          actionTable(124,"Faktor",SHIFT,120);
          actionTable(124,"openP",SHIFT,112);
          actionTable(124,"ExpWert",SHIFT,130);
          actionTable(124,"Identifier",SHIFT,20);
          actionTable(124,"Term",SHIFT,126);
          actionTable(124,"minusP",SHIFT,16);
          actionTable(124,"ArrayKeyZugriff",SHIFT,31);
          actionTable(124,"identP",SHIFT,3);
          actionTable(124,"Produkt",SHIFT,125);
          actionTable(124,"numberP",SHIFT,15);
          actionTable(124,"ProzedurAufruf",SHIFT,25);

          actionTable(125,"geP",REDUCE,80);
          actionTable(125,"gtP",REDUCE,80);
          actionTable(125,"ltP",REDUCE,80);
          actionTable(125,"leP",REDUCE,80);
          actionTable(125,"neP",REDUCE,80);
          actionTable(125,"eqP",REDUCE,80);
          actionTable(125,"plusP",REDUCE,80);
          actionTable(125,"minusP",REDUCE,80);
          actionTable(125,"closeP",REDUCE,80);
          actionTable(125,"semikolonP",REDUCE,80);
          actionTable(125,"loopP",REDUCE,80);
          actionTable(125,"andP",REDUCE,80);
          actionTable(125,"orP",REDUCE,80);
          actionTable(125,"thenP",REDUCE,80);
          actionTable(125,"endP",REDUCE,80);
          actionTable(125,"zusicherungP",REDUCE,80);
          actionTable(125,"whileP",REDUCE,80);
          actionTable(125,"ifP",REDUCE,80);
          actionTable(125,"identP",REDUCE,80);
          actionTable(125,"elseP",REDUCE,80);

          actionTable(126,"HighPrecOp",SHIFT,128);
          actionTable(126,"multmultP",SHIFT,127);
          actionTable(126,"geP",REDUCE,85);
          actionTable(126,"gtP",REDUCE,85);
          actionTable(126,"ltP",REDUCE,85);
          actionTable(126,"leP",REDUCE,85);
          actionTable(126,"neP",REDUCE,85);
          actionTable(126,"eqP",REDUCE,85);
          actionTable(126,"plusP",REDUCE,85);
          actionTable(126,"minusP",REDUCE,85);
          actionTable(126,"multP",REDUCE,85);
          actionTable(126,"divP",REDUCE,85);
          actionTable(126,"modP",REDUCE,85);
          actionTable(126,"closeP",REDUCE,85);
          actionTable(126,"semikolonP",REDUCE,85);
          actionTable(126,"loopP",REDUCE,85);
          actionTable(126,"andP",REDUCE,85);
          actionTable(126,"orP",REDUCE,85);
          actionTable(126,"thenP",REDUCE,85);
          actionTable(126,"endP",REDUCE,85);
          actionTable(126,"zusicherungP",REDUCE,85);
          actionTable(126,"whileP",REDUCE,85);
          actionTable(126,"ifP",REDUCE,85);
          actionTable(126,"identP",REDUCE,85);
          actionTable(126,"elseP",REDUCE,85);

          actionTable(127,"openP",REDUCE,91);
          actionTable(127,"identP",REDUCE,91);
          actionTable(127,"minusP",REDUCE,91);
          actionTable(127,"numberP",REDUCE,91);

          actionTable(128,"IntWert",SHIFT,30);
          actionTable(128,"LinkedName",SHIFT,17);
          actionTable(128,"Faktor",SHIFT,129);
          actionTable(128,"openP",SHIFT,112);
          actionTable(128,"ExpWert",SHIFT,130);
          actionTable(128,"Identifier",SHIFT,20);
          actionTable(128,"Term",SHIFT,126);
          actionTable(128,"minusP",SHIFT,16);
          actionTable(128,"ArrayKeyZugriff",SHIFT,31);
          actionTable(128,"identP",SHIFT,3);
          actionTable(128,"numberP",SHIFT,15);
          actionTable(128,"ProzedurAufruf",SHIFT,25);

          actionTable(129,"geP",REDUCE,84);
          actionTable(129,"gtP",REDUCE,84);
          actionTable(129,"ltP",REDUCE,84);
          actionTable(129,"leP",REDUCE,84);
          actionTable(129,"neP",REDUCE,84);
          actionTable(129,"eqP",REDUCE,84);
          actionTable(129,"plusP",REDUCE,84);
          actionTable(129,"minusP",REDUCE,84);
          actionTable(129,"multP",REDUCE,84);
          actionTable(129,"divP",REDUCE,84);
          actionTable(129,"modP",REDUCE,84);
          actionTable(129,"closeP",REDUCE,84);
          actionTable(129,"semikolonP",REDUCE,84);
          actionTable(129,"loopP",REDUCE,84);
          actionTable(129,"andP",REDUCE,84);
          actionTable(129,"orP",REDUCE,84);
          actionTable(129,"thenP",REDUCE,84);
          actionTable(129,"endP",REDUCE,84);
          actionTable(129,"zusicherungP",REDUCE,84);
          actionTable(129,"whileP",REDUCE,84);
          actionTable(129,"ifP",REDUCE,84);
          actionTable(129,"identP",REDUCE,84);
          actionTable(129,"elseP",REDUCE,84);

          actionTable(130,"geP",REDUCE,90);
          actionTable(130,"gtP",REDUCE,90);
          actionTable(130,"ltP",REDUCE,90);
          actionTable(130,"leP",REDUCE,90);
          actionTable(130,"neP",REDUCE,90);
          actionTable(130,"eqP",REDUCE,90);
          actionTable(130,"plusP",REDUCE,90);
          actionTable(130,"minusP",REDUCE,90);
          actionTable(130,"multP",REDUCE,90);
          actionTable(130,"divP",REDUCE,90);
          actionTable(130,"modP",REDUCE,90);
          actionTable(130,"multmultP",REDUCE,90);
          actionTable(130,"closeP",REDUCE,90);
          actionTable(130,"semikolonP",REDUCE,90);
          actionTable(130,"loopP",REDUCE,90);
          actionTable(130,"andP",REDUCE,90);
          actionTable(130,"orP",REDUCE,90);
          actionTable(130,"thenP",REDUCE,90);
          actionTable(130,"endP",REDUCE,90);
          actionTable(130,"zusicherungP",REDUCE,90);
          actionTable(130,"whileP",REDUCE,90);
          actionTable(130,"ifP",REDUCE,90);
          actionTable(130,"identP",REDUCE,90);
          actionTable(130,"elseP",REDUCE,90);

          actionTable(131,"loopP",REDUCE,61);
          actionTable(131,"andP",REDUCE,61);
          actionTable(131,"orP",REDUCE,61);
          actionTable(131,"thenP",REDUCE,61);
          actionTable(131,"closeP",REDUCE,61);
          actionTable(131,"endP",REDUCE,61);
          actionTable(131,"zusicherungP",REDUCE,61);
          actionTable(131,"whileP",REDUCE,61);
          actionTable(131,"ifP",REDUCE,61);
          actionTable(131,"identP",REDUCE,61);
          actionTable(131,"elseP",REDUCE,61);

          actionTable(132,"geP",REDUCE,77);
          actionTable(132,"gtP",REDUCE,77);
          actionTable(132,"ltP",REDUCE,77);
          actionTable(132,"leP",REDUCE,77);
          actionTable(132,"neP",REDUCE,77);
          actionTable(132,"eqP",REDUCE,77);
          actionTable(132,"semikolonP",REDUCE,77);
          actionTable(132,"loopP",REDUCE,77);
          actionTable(132,"andP",REDUCE,77);
          actionTable(132,"orP",REDUCE,77);
          actionTable(132,"thenP",REDUCE,77);
          actionTable(132,"closeP",REDUCE,77);
          actionTable(132,"endP",REDUCE,77);
          actionTable(132,"zusicherungP",REDUCE,77);
          actionTable(132,"whileP",REDUCE,77);
          actionTable(132,"ifP",REDUCE,77);
          actionTable(132,"identP",REDUCE,77);
          actionTable(132,"elseP",REDUCE,77);

          actionTable(133,"closeP",SHIFT,114);
          actionTable(133,"geP",REDUCE,77);
          actionTable(133,"gtP",REDUCE,77);
          actionTable(133,"ltP",REDUCE,77);
          actionTable(133,"leP",REDUCE,77);
          actionTable(133,"neP",REDUCE,77);
          actionTable(133,"eqP",REDUCE,77);

          actionTable(134,"closeP",SHIFT,135);

          actionTable(135,"loopP",REDUCE,54);
          actionTable(135,"thenP",REDUCE,54);
          actionTable(135,"closeP",REDUCE,54);
          actionTable(135,"endP",REDUCE,54);
          actionTable(135,"zusicherungP",REDUCE,54);
          actionTable(135,"whileP",REDUCE,54);
          actionTable(135,"ifP",REDUCE,54);
          actionTable(135,"identP",REDUCE,54);
          actionTable(135,"elseP",REDUCE,54);

          actionTable(136,"loopP",REDUCE,55);
          actionTable(136,"thenP",REDUCE,55);
          actionTable(136,"closeP",REDUCE,55);
          actionTable(136,"endP",REDUCE,55);
          actionTable(136,"zusicherungP",REDUCE,55);
          actionTable(136,"whileP",REDUCE,55);
          actionTable(136,"ifP",REDUCE,55);
          actionTable(136,"identP",REDUCE,55);
          actionTable(136,"elseP",REDUCE,55);

          actionTable(137,"loopP",REDUCE,66);
          actionTable(137,"thenP",REDUCE,66);
          actionTable(137,"closeP",REDUCE,66);
          actionTable(137,"endP",REDUCE,66);
          actionTable(137,"zusicherungP",REDUCE,66);
          actionTable(137,"whileP",REDUCE,66);
          actionTable(137,"ifP",REDUCE,66);
          actionTable(137,"identP",REDUCE,66);
          actionTable(137,"elseP",REDUCE,66);

          actionTable(138,"loopP",REDUCE,65);
          actionTable(138,"thenP",REDUCE,65);
          actionTable(138,"closeP",REDUCE,65);
          actionTable(138,"endP",REDUCE,65);
          actionTable(138,"zusicherungP",REDUCE,65);
          actionTable(138,"whileP",REDUCE,65);
          actionTable(138,"ifP",REDUCE,65);
          actionTable(138,"identP",REDUCE,65);
          actionTable(138,"elseP",REDUCE,65);

          actionTable(139,"endP",REDUCE,32);
          actionTable(139,"zusicherungP",REDUCE,32);
          actionTable(139,"whileP",REDUCE,32);
          actionTable(139,"ifP",REDUCE,32);
          actionTable(139,"identP",REDUCE,32);
          actionTable(139,"elseP",REDUCE,32);

          actionTable(140,"leP",SHIFT,108);
          actionTable(140,"gtP",SHIFT,106);
          actionTable(140,"geP",SHIFT,105);
          actionTable(140,"VergleichOp",SHIFT,111);
          actionTable(140,"eqP",SHIFT,110);
          actionTable(140,"ltP",SHIFT,107);
          actionTable(140,"neP",SHIFT,109);
          actionTable(140,"endP",REDUCE,33);
          actionTable(140,"zusicherungP",REDUCE,33);
          actionTable(140,"whileP",REDUCE,33);
          actionTable(140,"ifP",REDUCE,33);
          actionTable(140,"identP",REDUCE,33);
          actionTable(140,"elseP",REDUCE,33);

          actionTable(141,"Summe",SHIFT,132);
          actionTable(141,"openP",SHIFT,89);
          actionTable(141,"numberP",SHIFT,15);
          actionTable(141,"ExpWert",SHIFT,130);
          actionTable(141,"Quantor",SHIFT,101);
          actionTable(141,"ExQuantor",SHIFT,103);
          actionTable(141,"Ausdruck",SHIFT,104);
          actionTable(141,"IntWert",SHIFT,30);
          actionTable(141,"Faktor",SHIFT,120);
          actionTable(141,"Produkt",SHIFT,115);
          actionTable(141,"existsP",SHIFT,78);
          actionTable(141,"minusP",SHIFT,16);
          actionTable(141,"AllQuantor",SHIFT,102);
          actionTable(141,"notP",SHIFT,87);
          actionTable(141,"Term",SHIFT,126);
          actionTable(141,"forallP",SHIFT,85);
          actionTable(141,"LinkedName",SHIFT,17);
          actionTable(141,"ArrayKeyZugriff",SHIFT,31);
          actionTable(141,"identP",SHIFT,3);
          actionTable(141,"Bedingung",SHIFT,98);
          actionTable(141,"Identifier",SHIFT,20);
          actionTable(141,"Bedingungen",SHIFT,142);
          actionTable(141,"ProzedurAufruf",SHIFT,25);

          actionTable(142,"loopP",SHIFT,143);

          actionTable(143,"AProzedurAufruf",SHIFT,161);
          actionTable(143,"whileP",SHIFT,141);
          actionTable(143,"LinkedName",SHIFT,17);
          actionTable(143,"Anw",SHIFT,156);
          actionTable(143,"Zusicherung",SHIFT,158);
          actionTable(143,"Identifier",SHIFT,164);
          actionTable(143,"zusicherungP",SHIFT,75);
          actionTable(143,"AFall",SHIFT,163);
          actionTable(143,"Anwfolge",SHIFT,173);
          actionTable(143,"ifP",SHIFT,144);
          actionTable(143,"AZuweisung",SHIFT,159);
          actionTable(143,"identP",SHIFT,3);
          actionTable(143,"AArrayZuweisung",SHIFT,160);
          actionTable(143,"ProzedurAufruf",SHIFT,168);
          actionTable(143,"ASchleife",SHIFT,162);

          actionTable(144,"Summe",SHIFT,132);
          actionTable(144,"openP",SHIFT,89);
          actionTable(144,"numberP",SHIFT,15);
          actionTable(144,"ExpWert",SHIFT,130);
          actionTable(144,"Quantor",SHIFT,101);
          actionTable(144,"ExQuantor",SHIFT,103);
          actionTable(144,"Ausdruck",SHIFT,104);
          actionTable(144,"IntWert",SHIFT,30);
          actionTable(144,"Faktor",SHIFT,120);
          actionTable(144,"Produkt",SHIFT,115);
          actionTable(144,"existsP",SHIFT,78);
          actionTable(144,"minusP",SHIFT,16);
          actionTable(144,"AllQuantor",SHIFT,102);
          actionTable(144,"notP",SHIFT,87);
          actionTable(144,"Term",SHIFT,126);
          actionTable(144,"forallP",SHIFT,85);
          actionTable(144,"LinkedName",SHIFT,17);
          actionTable(144,"ArrayKeyZugriff",SHIFT,31);
          actionTable(144,"identP",SHIFT,3);
          actionTable(144,"Bedingung",SHIFT,98);
          actionTable(144,"Identifier",SHIFT,20);
          actionTable(144,"Bedingungen",SHIFT,145);
          actionTable(144,"ProzedurAufruf",SHIFT,25);

          actionTable(145,"thenP",SHIFT,146);

          actionTable(146,"AProzedurAufruf",SHIFT,161);
          actionTable(146,"whileP",SHIFT,141);
          actionTable(146,"LinkedName",SHIFT,17);
          actionTable(146,"Anw",SHIFT,156);
          actionTable(146,"Zusicherung",SHIFT,158);
          actionTable(146,"Identifier",SHIFT,164);
          actionTable(146,"zusicherungP",SHIFT,75);
          actionTable(146,"AFall",SHIFT,163);
          actionTable(146,"Anwfolge",SHIFT,147);
          actionTable(146,"ifP",SHIFT,144);
          actionTable(146,"AZuweisung",SHIFT,159);
          actionTable(146,"identP",SHIFT,3);
          actionTable(146,"AArrayZuweisung",SHIFT,160);
          actionTable(146,"ProzedurAufruf",SHIFT,168);
          actionTable(146,"ASchleife",SHIFT,162);

          actionTable(147,"elseP",SHIFT,151);
          actionTable(147,"endP",SHIFT,148);

          actionTable(148,"ifP",SHIFT,149);

          actionTable(149,"semikolonP",SHIFT,150);

          actionTable(150,"endP",REDUCE,38);
          actionTable(150,"zusicherungP",REDUCE,38);
          actionTable(150,"whileP",REDUCE,38);
          actionTable(150,"ifP",REDUCE,38);
          actionTable(150,"identP",REDUCE,38);
          actionTable(150,"elseP",REDUCE,38);

          actionTable(151,"AProzedurAufruf",SHIFT,161);
          actionTable(151,"whileP",SHIFT,141);
          actionTable(151,"LinkedName",SHIFT,17);
          actionTable(151,"Anw",SHIFT,156);
          actionTable(151,"Zusicherung",SHIFT,158);
          actionTable(151,"Identifier",SHIFT,164);
          actionTable(151,"zusicherungP",SHIFT,75);
          actionTable(151,"AFall",SHIFT,163);
          actionTable(151,"Anwfolge",SHIFT,152);
          actionTable(151,"ifP",SHIFT,144);
          actionTable(151,"AZuweisung",SHIFT,159);
          actionTable(151,"identP",SHIFT,3);
          actionTable(151,"AArrayZuweisung",SHIFT,160);
          actionTable(151,"ProzedurAufruf",SHIFT,168);
          actionTable(151,"ASchleife",SHIFT,162);

          actionTable(152,"endP",SHIFT,153);

          actionTable(153,"ifP",SHIFT,154);

          actionTable(154,"semikolonP",SHIFT,155);

          actionTable(155,"endP",REDUCE,39);
          actionTable(155,"zusicherungP",REDUCE,39);
          actionTable(155,"whileP",REDUCE,39);
          actionTable(155,"ifP",REDUCE,39);
          actionTable(155,"identP",REDUCE,39);
          actionTable(155,"elseP",REDUCE,39);

          actionTable(156,"AProzedurAufruf",SHIFT,161);
          actionTable(156,"whileP",SHIFT,141);
          actionTable(156,"LinkedName",SHIFT,17);
          actionTable(156,"Anw",SHIFT,156);
          actionTable(156,"Zusicherung",SHIFT,158);
          actionTable(156,"Identifier",SHIFT,164);
          actionTable(156,"zusicherungP",SHIFT,75);
          actionTable(156,"AFall",SHIFT,163);
          actionTable(156,"Anwfolge",SHIFT,157);
          actionTable(156,"ifP",SHIFT,144);
          actionTable(156,"AZuweisung",SHIFT,159);
          actionTable(156,"identP",SHIFT,3);
          actionTable(156,"AArrayZuweisung",SHIFT,160);
          actionTable(156,"ProzedurAufruf",SHIFT,168);
          actionTable(156,"ASchleife",SHIFT,162);
          actionTable(156,"endP",REDUCE,18);
          actionTable(156,"elseP",REDUCE,18);

          actionTable(157,"endP",REDUCE,17);
          actionTable(157,"elseP",REDUCE,17);

          actionTable(158,"endP",REDUCE,23);
          actionTable(158,"zusicherungP",REDUCE,23);
          actionTable(158,"whileP",REDUCE,23);
          actionTable(158,"ifP",REDUCE,23);
          actionTable(158,"identP",REDUCE,23);
          actionTable(158,"elseP",REDUCE,23);

          actionTable(159,"endP",REDUCE,24);
          actionTable(159,"zusicherungP",REDUCE,24);
          actionTable(159,"whileP",REDUCE,24);
          actionTable(159,"ifP",REDUCE,24);
          actionTable(159,"identP",REDUCE,24);
          actionTable(159,"elseP",REDUCE,24);

          actionTable(160,"endP",REDUCE,25);
          actionTable(160,"zusicherungP",REDUCE,25);
          actionTable(160,"whileP",REDUCE,25);
          actionTable(160,"ifP",REDUCE,25);
          actionTable(160,"identP",REDUCE,25);
          actionTable(160,"elseP",REDUCE,25);

          actionTable(161,"endP",REDUCE,26);
          actionTable(161,"zusicherungP",REDUCE,26);
          actionTable(161,"whileP",REDUCE,26);
          actionTable(161,"ifP",REDUCE,26);
          actionTable(161,"identP",REDUCE,26);
          actionTable(161,"elseP",REDUCE,26);

          actionTable(162,"endP",REDUCE,27);
          actionTable(162,"zusicherungP",REDUCE,27);
          actionTable(162,"whileP",REDUCE,27);
          actionTable(162,"ifP",REDUCE,27);
          actionTable(162,"identP",REDUCE,27);
          actionTable(162,"elseP",REDUCE,27);

          actionTable(163,"endP",REDUCE,28);
          actionTable(163,"zusicherungP",REDUCE,28);
          actionTable(163,"whileP",REDUCE,28);
          actionTable(163,"ifP",REDUCE,28);
          actionTable(163,"identP",REDUCE,28);
          actionTable(163,"elseP",REDUCE,28);

          actionTable(164,"punktP",SHIFT,23);
          actionTable(164,"zuweisungP",SHIFT,165);
          actionTable(164,"openP",REDUCE,13);

          actionTable(165,"IntWert",SHIFT,30);
          actionTable(165,"Summe",SHIFT,132);
          actionTable(165,"LinkedName",SHIFT,17);
          actionTable(165,"Faktor",SHIFT,120);
          actionTable(165,"openP",SHIFT,112);
          actionTable(165,"ExpWert",SHIFT,130);
          actionTable(165,"Identifier",SHIFT,20);
          actionTable(165,"Term",SHIFT,126);
          actionTable(165,"Ausdruck",SHIFT,166);
          actionTable(165,"minusP",SHIFT,16);
          actionTable(165,"ArrayKeyZugriff",SHIFT,31);
          actionTable(165,"identP",SHIFT,3);
          actionTable(165,"Produkt",SHIFT,115);
          actionTable(165,"numberP",SHIFT,15);
          actionTable(165,"ProzedurAufruf",SHIFT,25);

          actionTable(166,"semikolonP",SHIFT,167);

          actionTable(167,"endP",REDUCE,34);
          actionTable(167,"zusicherungP",REDUCE,34);
          actionTable(167,"whileP",REDUCE,34);
          actionTable(167,"ifP",REDUCE,34);
          actionTable(167,"identP",REDUCE,34);
          actionTable(167,"elseP",REDUCE,34);

          actionTable(168,"zuweisungP",SHIFT,170);
          actionTable(168,"semikolonP",SHIFT,169);

          actionTable(169,"endP",REDUCE,36);
          actionTable(169,"zusicherungP",REDUCE,36);
          actionTable(169,"whileP",REDUCE,36);
          actionTable(169,"ifP",REDUCE,36);
          actionTable(169,"identP",REDUCE,36);
          actionTable(169,"elseP",REDUCE,36);

          actionTable(170,"IntWert",SHIFT,30);
          actionTable(170,"Summe",SHIFT,132);
          actionTable(170,"LinkedName",SHIFT,17);
          actionTable(170,"Faktor",SHIFT,120);
          actionTable(170,"openP",SHIFT,112);
          actionTable(170,"ExpWert",SHIFT,130);
          actionTable(170,"Identifier",SHIFT,20);
          actionTable(170,"Term",SHIFT,126);
          actionTable(170,"Ausdruck",SHIFT,171);
          actionTable(170,"minusP",SHIFT,16);
          actionTable(170,"ArrayKeyZugriff",SHIFT,31);
          actionTable(170,"identP",SHIFT,3);
          actionTable(170,"Produkt",SHIFT,115);
          actionTable(170,"numberP",SHIFT,15);
          actionTable(170,"ProzedurAufruf",SHIFT,25);

          actionTable(171,"semikolonP",SHIFT,172);

          actionTable(172,"endP",REDUCE,35);
          actionTable(172,"zusicherungP",REDUCE,35);
          actionTable(172,"whileP",REDUCE,35);
          actionTable(172,"ifP",REDUCE,35);
          actionTable(172,"identP",REDUCE,35);
          actionTable(172,"elseP",REDUCE,35);

          actionTable(173,"endP",SHIFT,174);

          actionTable(174,"loopP",SHIFT,175);

          actionTable(175,"semikolonP",SHIFT,176);

          actionTable(176,"endP",REDUCE,37);
          actionTable(176,"zusicherungP",REDUCE,37);
          actionTable(176,"whileP",REDUCE,37);
          actionTable(176,"ifP",REDUCE,37);
          actionTable(176,"identP",REDUCE,37);
          actionTable(176,"elseP",REDUCE,37);

          actionTable(177,"endP",SHIFT,178);

          actionTable(178,"Identifier",SHIFT,179);
          actionTable(178,"identP",SHIFT,3);

          actionTable(179,"semikolonP",SHIFT,180);

          actionTable(180,"#",REDUCE,10);
          actionTable(180,"beginP",REDUCE,10);
          actionTable(180,"procedureP",REDUCE,10);
          actionTable(180,"identP",REDUCE,10);
          actionTable(180,"endP",REDUCE,10);

          actionTable(181,"bodyP",SHIFT,182);

          actionTable(182,"Identifier",SHIFT,183);
          actionTable(182,"identP",SHIFT,3);

          actionTable(183,"isP",SHIFT,184);

          actionTable(184,"Deklaration",SHIFT,8);
          actionTable(184,"procedureP",SHIFT,2);
          actionTable(184,"Identifier",SHIFT,54);
          actionTable(184,"Prozedur",SHIFT,6);
          actionTable(184,"identP",SHIFT,3);
          actionTable(184,"IdentifierList",SHIFT,10);
          actionTable(184,"DeklarationsBereich",SHIFT,189);
          actionTable(184,"ProzedurDeklarationen",SHIFT,185);

          actionTable(185,"endP",SHIFT,186);

          actionTable(186,"Identifier",SHIFT,187);
          actionTable(186,"identP",SHIFT,3);

          actionTable(187,"semikolonP",SHIFT,188);

          actionTable(188,"#",REDUCE,7);

          actionTable(189,"endP",REDUCE,11);

          actionTable(190,"LinkedName",SHIFT,191);
          actionTable(190,"Identifier",SHIFT,193);
          actionTable(190,"identP",SHIFT,3);

          actionTable(191,"semikolonP",SHIFT,192);

          actionTable(192,"procedureP",REDUCE,8);
          actionTable(192,"withP",REDUCE,8);
          actionTable(192,"useP",REDUCE,8);

          actionTable(193,"punktP",SHIFT,23);
          actionTable(193,"semikolonP",REDUCE,13);

          actionTable(194,"LinkedName",SHIFT,195);
          actionTable(194,"Identifier",SHIFT,193);
          actionTable(194,"identP",SHIFT,3);

          actionTable(195,"semikolonP",SHIFT,196);

          actionTable(196,"procedureP",REDUCE,9);
          actionTable(196,"withP",REDUCE,9);
          actionTable(196,"useP",REDUCE,9);

          actionTable(197,"#",ACCEPT);

          actionTable(198,"procedureP",SHIFT,2);
          actionTable(198,"HauptProzedur",SHIFT,199);
          actionTable(198,"Prozedur",SHIFT,200);

          actionTable(199,"#",REDUCE,1);

          actionTable(200,"#",REDUCE,6);

          actionTable(201,"#",REDUCE,2);

          actionTable(202,"#",REDUCE,3);

          actionTable(203,"Import",SHIFT,203);
          actionTable(203,"withP",SHIFT,190);
          actionTable(203,"useP",SHIFT,194);
          actionTable(203,"ImportBereich",SHIFT,204);
          actionTable(203,"procedureP",REDUCE,5);

          actionTable(204,"procedureP",REDUCE,4);

     }
}